home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / sfilter1.c < prev    next >
C/C++ Source or Header  |  1997-03-28  |  7KB  |  288 lines
  1. /* Copyright (C) 1993, 1995, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* sfilter1.c */
  20. /* Filters included in Level 1 systems: NullEncode/Decode, PFBDecode, */
  21. /*   SubFileDecode. */
  22. #include "stdio_.h"        /* includes std.h */
  23. #include "memory_.h"
  24. #include "strimpl.h"
  25. #include "sfilter.h"
  26.  
  27. /* ------ NullEncode/Decode ------ */
  28.  
  29. /* Process a buffer */
  30. private int
  31. s_Null_process(stream_state *st, stream_cursor_read *pr,
  32.   stream_cursor_write *pw, bool last)
  33. {    return stream_move(pr, pw);
  34. }
  35.  
  36. /* Stream template */
  37. const stream_template s_Null_template =
  38. {    &st_stream_state, NULL, s_Null_process, 1, 1
  39. };
  40.  
  41. /* ------ PFBDecode ------ */
  42.  
  43. private_st_PFBD_state();
  44.  
  45. #define ss ((stream_PFBD_state *)st)
  46.  
  47. /* Initialize the state */
  48. private int
  49. s_PFBD_init(stream_state *st)
  50. {    ss->record_type = -1;
  51.     return 0;
  52. }
  53.  
  54. /* Process a buffer */
  55. private int
  56. s_PFBD_process(stream_state *st, stream_cursor_read *pr,
  57.   stream_cursor_write *pw, bool last)
  58. {    register const byte *p = pr->ptr;
  59.     register byte *q = pw->ptr;
  60.     int rcount, wcount;
  61.     int c;
  62.     int status = 0;
  63. top:    rcount = pr->limit - p;
  64.     wcount = pw->limit - q;
  65.     switch ( ss->record_type )
  66.     {
  67.     case -1:            /* new record */
  68.         if ( rcount < 2 )
  69.             goto out;
  70.         if ( p[1] != 0x80 )
  71.             goto err;
  72.         c = p[2];
  73.         switch ( c )
  74.         {
  75.         case 1: case 2:
  76.             break;
  77.         case 3:
  78.             status = EOFC;
  79.             p += 2;
  80.             goto out;
  81.         default:
  82.             p += 2;
  83.             goto err;
  84.         }
  85.         if ( rcount < 6 )
  86.             goto out;
  87.         ss->record_type = c;
  88.         ss->record_left = p[3] + ((uint)p[4] << 8) +
  89.                     ((ulong)p[5] << 16) +
  90.                     ((ulong)p[6] << 24);
  91.         p += 6;
  92.         goto top;
  93.     case 1:                /* text data */
  94.         /* Translate \r to \n. */
  95.     {    int count = (wcount < rcount ? (status = 1, wcount) : rcount);
  96.         if ( count > ss->record_left )
  97.             count = ss->record_left,
  98.             status = 0;
  99.         ss->record_left -= count;
  100.         for ( ; count != 0; count-- )
  101.         {    c = *++p;
  102.             *++q = (c == '\r' ? '\n' : c);
  103.         }
  104.     }    break;
  105.     case 2:                /* binary data */
  106.         if ( ss->binary_to_hex )
  107.         {    /* Translate binary to hex. */
  108.             int count;
  109.             register const char _ds *hex_digits =
  110.                             "0123456789abcdef";
  111.             wcount >>= 1;        /* 2 chars per input byte */
  112.             count = (wcount < rcount ? (status = 1, wcount) : rcount);
  113.             if ( count > ss->record_left )
  114.                 count = ss->record_left,
  115.                 status = 0;
  116.             ss->record_left -= count;
  117.             for ( ; count != 0; count-- )
  118.             {    c = *++p;
  119.                 q[1] = hex_digits[c >> 4];
  120.                 q[2] = hex_digits[c & 0xf];
  121.                 q += 2;
  122.             }
  123.         }
  124.         else
  125.         {    /* Just read binary data. */
  126.             int count = (wcount < rcount ? (status = 1, wcount) : rcount);
  127.             if ( count > ss->record_left )
  128.                 count = ss->record_left,
  129.                 status = 0;
  130.             ss->record_left -= count;
  131.             memcpy(q + 1, p + 1, count);
  132.             p += count;
  133.             q += count;
  134.         }
  135.         break;
  136.        }
  137.     if ( ss->record_left == 0 )
  138.     {    ss->record_type = -1;
  139.         goto top;
  140.     }
  141. out:    pr->ptr = p;
  142.     pw->ptr = q;
  143.     return status;
  144. err:    pr->ptr = p;
  145.     pw->ptr = q;
  146.     return ERRC;
  147. }
  148.  
  149. #undef ss
  150.  
  151. /* Stream template */
  152. const stream_template s_PFBD_template =
  153. {    &st_PFBD_state, s_PFBD_init, s_PFBD_process, 6, 2
  154. };
  155.  
  156. /* ------ SubFileDecode ------ */
  157.  
  158. private_st_SFD_state();
  159. /* GC procedures */
  160. private ENUM_PTRS_BEGIN(sfd_enum_ptrs) return 0;
  161.     ENUM_CONST_STRING_PTR(0, stream_SFD_state, eod);
  162. ENUM_PTRS_END
  163. private RELOC_PTRS_BEGIN(sfd_reloc_ptrs) ;
  164.     RELOC_CONST_STRING_PTR(stream_SFD_state, eod);
  165. RELOC_PTRS_END
  166.  
  167. #define ss ((stream_SFD_state *)st)
  168.  
  169. /* Initialize the stream */
  170. private int
  171. s_SFD_init(stream_state *st)
  172. {    ss->match = 0;
  173.     ss->copy_count = 0;
  174.     return 0;
  175. }
  176.  
  177. /* Refill the buffer */
  178. private int
  179. s_SFD_process(stream_state *st, stream_cursor_read *pr,
  180.   stream_cursor_write *pw, bool last)
  181. {    register const byte *p = pr->ptr;
  182.     register byte *q = pw->ptr;
  183.     const byte *rlimit = pr->limit;
  184.     byte *wlimit = pw->limit;
  185.     int status = 0;
  186.     if ( ss->eod.size == 0 )
  187.     {    /* Just read, with no EOD pattern. */
  188.         int rcount = rlimit - p;
  189.         int wcount = wlimit - q;
  190.         int count = min(rcount, wcount);
  191.         if ( ss->count == 0 )        /* no EOD limit */
  192.             return stream_move(pr, pw);
  193.         else if ( ss->count > count )    /* not EOD yet */
  194.         {    ss->count -= count;
  195.             return stream_move(pr, pw);
  196.         }
  197.         else
  198.         {    /* We're going to reach EOD. */
  199.             count = ss->count;
  200.             memcpy(q + 1, p + 1, count);
  201.             pr->ptr = p + count;
  202.             pw->ptr = q + count;
  203.             return EOFC;
  204.         }
  205.     }
  206.     else
  207.     {    /* Read looking for an EOD pattern. */
  208.         const byte *pattern = ss->eod.data;
  209.         uint match = ss->match;
  210. cp:        /* Check whether we're still copying a partial match. */
  211.         if ( ss->copy_count )
  212.         {    int count = min(wlimit - q, ss->copy_count);
  213.             memcpy(q + 1, ss->eod.data + ss->copy_ptr, count);
  214.             ss->copy_count -= count;
  215.             ss->copy_ptr += count;
  216.             q += count;
  217.             if ( ss->copy_count != 0 )    /* hit wlimit */
  218.             {    status = 1;
  219.                 goto xit;
  220.             }
  221.             else if ( ss->count < 0 )
  222.             {    status = EOFC;
  223.                 goto xit;
  224.             }
  225.         }
  226.         while ( p < rlimit )
  227.         {    int c = *++p;
  228.             if ( c == pattern[match] )
  229.             {    if ( ++match == ss->eod.size )
  230.                 {    switch ( ss->count )
  231.                     {
  232.                     case 0:
  233.                         status = EOFC;
  234.                         goto xit;
  235.                     case 1:
  236.                         ss->count = -1;
  237.                         break;
  238.                     default:
  239.                         ss->count--;
  240.                     }
  241.                     ss->copy_ptr = 0;
  242.                     ss->copy_count = match;
  243.                     match = 0;
  244.                     goto cp;
  245.                 }
  246.                 continue;
  247.             }
  248.             /* No match here, back up to find the longest one. */
  249.             /* This may be quadratic in string_size, but */
  250.             /* we don't expect this to be a real problem. */
  251.             if ( match > 0 )
  252.               {    int end = match;
  253.                 while ( match > 0 )
  254.                   {    match--;
  255.                     if ( !memcmp(pattern,
  256.                              pattern + end - match,
  257.                              match)
  258.                        )
  259.                       break;
  260.                   }
  261.                 /* Copy the unmatched initial portion of */
  262.                 /* the EOD string to the output. */
  263.                 p--;
  264.                 ss->copy_ptr = 0;
  265.                 ss->copy_count = end - match;
  266.                 goto cp;
  267.               }
  268.             if ( q == wlimit )
  269.             {    p--;
  270.                 status = 1;
  271.                 break;
  272.             }
  273.             *++q = c;
  274.         }
  275. xit:        pr->ptr = p;
  276.         pw->ptr = q;
  277.         ss->match = match;
  278.     }
  279.     return status;
  280. }
  281.  
  282. #undef ss
  283.  
  284. /* Stream template */
  285. const stream_template s_SFD_template =
  286. {    &st_SFD_state, s_SFD_init, s_SFD_process, 1, 1
  287. };
  288.